home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Freeware / Miro 1.0 / Miro_Installer.exe / Miro_Downloader.exe / test / databasetest.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-11-12  |  59.0 KB  |  1,836 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import unittest
  5. import database
  6. from os import remove
  7. from os.path import expanduser
  8. import random
  9. import config
  10. import prefs
  11. import os
  12. import random
  13. import shutil
  14. import time
  15. import tempfile
  16. import storedatabase
  17. from threading import Thread
  18. from test.framework import DemocracyTestCase
  19.  
  20. class SortableObject(database.DDBObject):
  21.     
  22.     def __init__(self, value):
  23.         self.value = value
  24.         database.DDBObject.__init__(self)
  25.  
  26.  
  27.  
  28. class EmptyViewTestCase(DemocracyTestCase):
  29.     
  30.     def setUp(self):
  31.         DemocracyTestCase.setUp(self)
  32.         self.everything = database.defaultDatabase
  33.  
  34.     
  35.     def testCur(self):
  36.         self.everything.resetCursor()
  37.         self.assertEqual(self.everything.cur(), None)
  38.  
  39.     
  40.     def testNext(self):
  41.         self.everything.resetCursor()
  42.         self.assertEqual(self.everything.getNext(), None)
  43.  
  44.     
  45.     def testGetItem(self):
  46.         self.assertEqual(self.everything[0], None)
  47.  
  48.     
  49.     def testGetPrev(self):
  50.         self.everything.resetCursor()
  51.         self.assertEqual(self.everything.getPrev(), None)
  52.  
  53.     
  54.     def testLen(self):
  55.         self.assertEqual(self.everything.len(), 0)
  56.  
  57.  
  58.  
  59. class SingleItemViewTestCase(DemocracyTestCase):
  60.     
  61.     def setUp(self):
  62.         DemocracyTestCase.setUp(self)
  63.         self.everything = database.defaultDatabase
  64.         self.x = database.DDBObject()
  65.  
  66.     
  67.     def testAdd(self):
  68.         self.assertEqual(self.x.__class__, database.DDBObject)
  69.  
  70.     
  71.     def testGetItem(self):
  72.         a = self.everything[0]
  73.         b = self.everything[1]
  74.         self.assertEqual(a.__class__, database.DDBObject)
  75.         self.assertEqual(b, None)
  76.  
  77.     
  78.     def testNext(self):
  79.         self.everything.resetCursor()
  80.         a = self.everything.cur()
  81.         b = self.everything.getNext()
  82.         c = self.everything.cur()
  83.         d = self.everything.getNext()
  84.         if not a == None and b.__class__ == database.DDBObject and c == b or d == None:
  85.             raise AssertionError
  86.  
  87.     
  88.     def testGetPrev(self):
  89.         self.everything.resetCursor()
  90.         self.assertEqual(self.everything.getPrev(), None)
  91.  
  92.     
  93.     def testLen(self):
  94.         self.assertEqual(self.everything.len(), 1)
  95.  
  96.  
  97.  
  98. class AddBeforeViewTestCase(DemocracyTestCase):
  99.     
  100.     def setUp(self):
  101.         DemocracyTestCase.setUp(self)
  102.         self.x = database.DDBObject()
  103.         self.y = database.DDBObject()
  104.         database.resetDefaultDatabase()
  105.         self.everything = database.defaultDatabase
  106.         self.everything.addBeforeCursor(self.y)
  107.         self.everything.resetCursor()
  108.         self.everything.addBeforeCursor(self.x)
  109.  
  110.     
  111.     def testUnique(self):
  112.         self.assertNotEqual(self.x, self.y)
  113.  
  114.     
  115.     def testUniqueID(self):
  116.         self.assertNotEqual(self.x.getID(), self.y.getID())
  117.  
  118.     
  119.     def testGetItem(self):
  120.         a = self.everything[0]
  121.         b = self.everything[1]
  122.         c = self.everything[2]
  123.         self.assertEqual(a.__class__, database.DDBObject)
  124.         self.assertEqual(b.__class__, database.DDBObject)
  125.         self.assertNotEqual(a, b)
  126.         self.assertEqual(c, None)
  127.  
  128.     
  129.     def testNextGetPrev(self):
  130.         self.everything.resetCursor()
  131.         a = self.everything.cur()
  132.         b = self.everything.getNext()
  133.         c = self.everything.cur()
  134.         d = self.everything.getNext()
  135.         e = self.everything.cur()
  136.         f = self.everything.getNext()
  137.         if not a == None and b.__class__ == database.DDBObject and c == b and d.__class__ == database.DDBObject and d != c and d == e or f == None:
  138.             raise AssertionError
  139.  
  140.     
  141.     def testLen(self):
  142.         self.assertEqual(self.everything.len(), 2)
  143.  
  144.  
  145.  
  146. class AddAfterViewTestCase(DemocracyTestCase):
  147.     
  148.     def setUp(self):
  149.         DemocracyTestCase.setUp(self)
  150.         self.x = database.DDBObject()
  151.         self.y = database.DDBObject()
  152.         database.resetDefaultDatabase()
  153.         self.everything = database.defaultDatabase
  154.         self.everything.addAfterCursor(self.x)
  155.         self.everything.resetCursor()
  156.         self.everything.getNext()
  157.         self.everything.addAfterCursor(self.y)
  158.  
  159.     
  160.     def testUnique(self):
  161.         self.assertNotEqual(self.x, self.y)
  162.  
  163.     
  164.     def testUniqueID(self):
  165.         self.assertNotEqual(self.x.getID(), self.y.getID())
  166.  
  167.     
  168.     def testGetItem(self):
  169.         a = self.everything[0]
  170.         b = self.everything[1]
  171.         c = self.everything[2]
  172.         self.assertEqual(a.__class__, database.DDBObject)
  173.         self.assertEqual(b.__class__, database.DDBObject)
  174.         self.assertNotEqual(a, b)
  175.         self.assertEqual(c, None)
  176.  
  177.     
  178.     def testNextGetPrev(self):
  179.         self.everything.resetCursor()
  180.         a = self.everything.cur()
  181.         b = self.everything.getNext()
  182.         c = self.everything.cur()
  183.         d = self.everything.getNext()
  184.         e = self.everything.cur()
  185.         f = self.everything.getNext()
  186.         if not a == None and b.__class__ == database.DDBObject and c == b and d.__class__ == database.DDBObject and d != c and d == e or f == None:
  187.             raise AssertionError
  188.  
  189.     
  190.     def testLen(self):
  191.         self.assertEqual(self.everything.len(), 2)
  192.  
  193.  
  194.  
  195. class DeletedItemViewTestCase(DemocracyTestCase):
  196.     
  197.     def setUp(self):
  198.         DemocracyTestCase.setUp(self)
  199.         self.everything = database.defaultDatabase
  200.         self.x = database.DDBObject()
  201.         self.y = database.DDBObject()
  202.         self.x.remove()
  203.  
  204.     
  205.     def testRemoveMissing(self):
  206.         self.everything.resetCursor()
  207.         self.assertRaises(database.ObjectNotFoundError, self.everything.remove)
  208.  
  209.     
  210.     def testAdd(self):
  211.         self.assertEqual(self.x.__class__, database.DDBObject)
  212.  
  213.     
  214.     def testGetItem(self):
  215.         a = self.everything[0]
  216.         b = self.everything[1]
  217.         self.assertEqual(a, self.y)
  218.         self.assertEqual(b, None)
  219.  
  220.     
  221.     def testNext(self):
  222.         self.everything.resetCursor()
  223.         a = self.everything.cur()
  224.         b = self.everything.getNext()
  225.         c = self.everything.cur()
  226.         d = self.everything.getNext()
  227.         if not a == None and b.__class__ == database.DDBObject and c == b or d == None:
  228.             raise AssertionError
  229.  
  230.     
  231.     def testLen(self):
  232.         self.assertEqual(self.everything.len(), 1)
  233.  
  234.  
  235.  
  236. class FilterViewTestCase(DemocracyTestCase):
  237.     
  238.     def setUp(self):
  239.         DemocracyTestCase.setUp(self)
  240.         self.everything = database.defaultDatabase
  241.         self.x = database.DDBObject()
  242.         self.y = database.DDBObject()
  243.         self.filtered = (self.everything.filter,)((lambda q: q != self.x))
  244.  
  245.     
  246.     def testGetItem(self):
  247.         a = self.filtered[0]
  248.         b = self.filtered[1]
  249.         self.assertEqual(a, self.y)
  250.         self.assertEqual(b, None)
  251.  
  252.     
  253.     def testNext(self):
  254.         self.filtered.resetCursor()
  255.         a = self.filtered.cur()
  256.         b = self.filtered.getNext()
  257.         c = self.filtered.cur()
  258.         d = self.filtered.getNext()
  259.         if not a == None and b == self.y and c == b or d == None:
  260.             raise AssertionError
  261.  
  262.     
  263.     def testGetPrev(self):
  264.         self.filtered.resetCursor()
  265.         self.assertEqual(self.filtered.getPrev(), None)
  266.  
  267.     
  268.     def testLen(self):
  269.         self.assertEqual(self.filtered.len(), 1)
  270.  
  271.  
  272.  
  273. class RecomputeFilterViewTestCase(DemocracyTestCase):
  274.     
  275.     def setUp(self):
  276.         DemocracyTestCase.setUp(self)
  277.         self.everything = database.defaultDatabase
  278.         self.x = database.DDBObject()
  279.         self.y = database.DDBObject()
  280.         self.accept = self.x.getID()
  281.         self.filtered = self.everything.filter(self.changeFilt)
  282.         self.accept = self.y.getID()
  283.         self.everything.recomputeFilters()
  284.  
  285.     
  286.     def changeFilt(self, obj):
  287.         return obj.getID() == self.accept
  288.  
  289.     
  290.     def testGetItem(self):
  291.         a = self.filtered[0]
  292.         b = self.filtered[1]
  293.         self.assertEqual(a, self.y)
  294.         self.assertEqual(b, None)
  295.  
  296.     
  297.     def testNext(self):
  298.         self.filtered.resetCursor()
  299.         a = self.filtered.cur()
  300.         b = self.filtered.getNext()
  301.         c = self.filtered.cur()
  302.         d = self.filtered.getNext()
  303.         if not a == None and b == self.y and c == b or d == None:
  304.             raise AssertionError
  305.  
  306.     
  307.     def testGetPrev(self):
  308.         self.filtered.resetCursor()
  309.         self.assertEqual(self.filtered.getPrev(), None)
  310.  
  311.     
  312.     def testLen(self):
  313.         self.assertEqual(self.filtered.len(), 1)
  314.  
  315.  
  316.  
  317. class SortTestCase(DemocracyTestCase):
  318.     
  319.     def setUp(self):
  320.         DemocracyTestCase.setUp(self)
  321.         self.everything = database.defaultDatabase
  322.         self.x = database.DDBObject()
  323.         self.y = database.DDBObject()
  324.         self.higher = self.x
  325.         self.sorted = self.everything.sort(self.sortFunc)
  326.  
  327.     
  328.     def sortFunc(self, x, y):
  329.         return x[1] != self.higher
  330.  
  331.     
  332.     def testUnique(self):
  333.         self.assertNotEqual(self.x, self.y)
  334.  
  335.     
  336.     def testUniqueID(self):
  337.         self.assertNotEqual(self.x.getID(), self.y.getID())
  338.  
  339.     
  340.     def testGetItem(self):
  341.         a = self.sorted[0]
  342.         b = self.sorted[1]
  343.         c = self.sorted[2]
  344.         self.assertEqual(a, self.y)
  345.         self.assertEqual(b, self.x)
  346.         self.assertNotEqual(a, b)
  347.         self.assertEqual(c, None)
  348.  
  349.     
  350.     def testNextGetPrev(self):
  351.         self.sorted.resetCursor()
  352.         a = self.sorted.cur()
  353.         b = self.sorted.getNext()
  354.         c = self.sorted.cur()
  355.         d = self.sorted.getNext()
  356.         e = self.sorted.cur()
  357.         f = self.sorted.getNext()
  358.         if not a == None and b.__class__ == database.DDBObject and c == b and d.__class__ == database.DDBObject and d != c and d == e or f == None:
  359.             raise AssertionError
  360.  
  361.     
  362.     def testLen(self):
  363.         self.assertEqual(self.everything.len(), 2)
  364.  
  365.     
  366.     def testRecompute(self):
  367.         self.higher = self.y
  368.         self.everything.recomputeFilters()
  369.         a = self.sorted[0]
  370.         b = self.sorted[1]
  371.         c = self.sorted[2]
  372.         self.assertEqual(a, self.x)
  373.         self.assertEqual(b, self.y)
  374.         self.assertNotEqual(a, b)
  375.         self.assertEqual(c, None)
  376.  
  377.     
  378.     def testSignalChange(self):
  379.         self.higher = self.y
  380.         self.assertEqual(self.sorted[0], self.y)
  381.         self.assertEqual(self.sorted[1], self.x)
  382.         self.x.signalChange()
  383.         self.assertEqual(self.sorted[0], self.y)
  384.         self.assertEqual(self.sorted[1], self.x)
  385.  
  386.     
  387.     def testResort(self):
  388.         self.sorted = self.everything.sort(self.sortFunc, resort = True)
  389.         self.assertEqual(self.sorted[0], self.y)
  390.         self.assertEqual(self.sorted[1], self.x)
  391.         self.higher = self.y
  392.         self.x.signalChange()
  393.         self.assertEqual(self.sorted[0], self.x)
  394.         self.assertEqual(self.sorted[1], self.y)
  395.  
  396.  
  397.  
  398. class MapViewTestCase(DemocracyTestCase):
  399.     
  400.     def setUp(self):
  401.         DemocracyTestCase.setUp(self)
  402.         self.everything = database.defaultDatabase
  403.         self.x = database.DDBObject()
  404.         self.y = database.DDBObject()
  405.         self.add = 0
  406.         self.mapped = self.everything.map(self.mapFunc)
  407.  
  408.     
  409.     def mapFunc(self, obj):
  410.         return obj.getID() + self.add
  411.  
  412.     
  413.     def testNotAltered(self):
  414.         self.assertNotEqual(self.x, self.mapped[0])
  415.         self.assertNotEqual(self.x, self.mapped[1])
  416.         self.assertNotEqual(self.y, self.mapped[0])
  417.         self.assertNotEqual(self.y, self.mapped[1])
  418.  
  419.     
  420.     def testUnique(self):
  421.         self.assertNotEqual(self.x, self.y)
  422.  
  423.     
  424.     def testUniqueID(self):
  425.         self.assertNotEqual(self.x.getID(), self.y.getID())
  426.  
  427.     
  428.     def testGetItem(self):
  429.         a = self.mapped[0]
  430.         b = self.mapped[1]
  431.         c = self.mapped[2]
  432.         self.assertEqual(a, self.everything[0].getID())
  433.         self.assertEqual(b, self.everything[1].getID())
  434.         self.assertNotEqual(a, b)
  435.         self.assertEqual(c, None)
  436.  
  437.     
  438.     def testNextGetPrev(self):
  439.         self.mapped.resetCursor()
  440.         a = self.mapped.cur()
  441.         b = self.mapped.getNext()
  442.         c = self.mapped.cur()
  443.         d = self.mapped.getNext()
  444.         e = self.mapped.cur()
  445.         f = self.mapped.getNext()
  446.         if not a == None and b.__class__.__name__ == 'int' and c == b and d.__class__.__name__ == 'int' and d != c and d == e or f == None:
  447.             raise AssertionError
  448.  
  449.     
  450.     def testLen(self):
  451.         self.assertEqual(self.everything.len(), 2)
  452.  
  453.  
  454.  
  455. class CallbackViewTestCase(DemocracyTestCase):
  456.     
  457.     def setUp(self):
  458.         DemocracyTestCase.setUp(self)
  459.         self.everything = database.defaultDatabase
  460.         self.filtered = self.everything.filter((lambda x: True))
  461.         self.mapped = self.everything.map((lambda x: x))
  462.         self.sorted = self.everything.sort((lambda x, y: 0))
  463.         self.callcount = 0
  464.  
  465.     
  466.     def call(self, obj, id):
  467.         if not id == self.everything[0].getID():
  468.             raise AssertionError
  469.         self.callcount += 1
  470.  
  471.     
  472.     def removeCall(self, obj, id):
  473.         self.callcount += 1
  474.  
  475.     
  476.     def testAdd(self):
  477.         self.everything.addAddCallback(self.call)
  478.         self.x = database.DDBObject()
  479.         self.assertEqual(self.callcount, 1)
  480.  
  481.     
  482.     def testChange(self):
  483.         self.everything.addChangeCallback(self.call)
  484.         self.x = database.DDBObject()
  485.         self.x.signalChange()
  486.         self.assertEqual(self.callcount, 1)
  487.  
  488.     
  489.     def testRemove(self):
  490.         self.everything.addRemoveCallback(self.removeCall)
  491.         self.x = database.DDBObject()
  492.         self.x.remove()
  493.         self.assertEqual(self.callcount, 1)
  494.  
  495.     
  496.     def TestFilterAdd(self):
  497.         self.filtered.addAddCallBack(self.call)
  498.         self.x = database.DDBObject()
  499.         self.assertEqual(self.callcount, 1)
  500.  
  501.     
  502.     def TestFilterRemove(self):
  503.         self.filtered.addRemoveCallBack(self.call)
  504.         self.x = database.DDBObject()
  505.         self.x.remove()
  506.         self.assertEqual(self.callcount, 1)
  507.  
  508.     
  509.     def TestFilterChange(self):
  510.         self.filtered.addChangeCallBack(self.call)
  511.         self.x = database.DDBObject()
  512.         self.x.change()
  513.         self.assertEqual(self.callcount, 1)
  514.  
  515.     
  516.     def TestMapAdd(self):
  517.         self.mapped.addAddCallBack(self.call)
  518.         self.x = database.DDBObject()
  519.         self.assertEqual(self.callcount, 1)
  520.  
  521.     
  522.     def TestMapRemove(self):
  523.         self.mapped.addRemoveCallBack(self.call)
  524.         self.x = database.DDBObject()
  525.         self.x.remove()
  526.         self.assertEqual(self.callcount, 1)
  527.  
  528.     
  529.     def TestMapChange(self):
  530.         self.mapped.addChangeCallBack(self.call)
  531.         self.x = database.DDBObject()
  532.         self.x.change()
  533.         self.assertEqual(self.callcount, 1)
  534.  
  535.     
  536.     def TestSortAdd(self):
  537.         self.sorted.addAddCallBack(self.call)
  538.         self.x = database.DDBObject()
  539.         self.assertEqual(self.callcount, 1)
  540.  
  541.     
  542.     def TestSortRemove(self):
  543.         self.sorted.addRemoveCallBack(self.call)
  544.         self.x = database.DDBObject()
  545.         self.x.remove()
  546.         self.assertEqual(self.callcount, 1)
  547.  
  548.     
  549.     def TestSortChange(self):
  550.         self.sorted.addChangeCallBack(self.call)
  551.         self.x = database.DDBObject()
  552.         self.x.change()
  553.         self.assertEqual(self.callcount, 1)
  554.  
  555.  
  556.  
  557. class SaveRestoreTestCase(DemocracyTestCase):
  558.     
  559.     def setUp(self):
  560.         DemocracyTestCase.setUp(self)
  561.         self.tempdb = os.path.join(tempfile.gettempdir(), 'democracy-temp-db')
  562.         self.everything = database.defaultDatabase
  563.         self.everything.liveStorage = storedatabase.LiveStorage(self.tempdb, restore = False)
  564.         self.x = database.DDBObject()
  565.         self.y = database.DDBObject()
  566.  
  567.     
  568.     def tearDown(self):
  569.         self.everything.liveStorage.close()
  570.         self.everything.liveStorage = None
  571.         
  572.         try:
  573.             shutil.rmtree(self.tempdb)
  574.         except:
  575.             pass
  576.  
  577.         DemocracyTestCase.tearDown(self)
  578.  
  579.  
  580.  
  581. class BasicSaveTestCase(SaveRestoreTestCase):
  582.     
  583.     def testSaveRestore(self):
  584.         self.assertEqual(self.everything.len(), 2)
  585.         self.everything.liveStorage.saveDatabase()
  586.         self.everything.liveStorage.close()
  587.         self.z = database.DDBObject()
  588.         self.zz = database.DDBObject()
  589.         self.assertEqual(self.everything.len(), 4)
  590.         last = self.zz.getID()
  591.         self.x.remove()
  592.         self.everything.liveStorage = storedatabase.LiveStorage(self.tempdb)
  593.         self.assertEqual(self.everything.len(), 2)
  594.         if not self.everything[0].getID() == self.y.getID() and self.everything[0].getID() == self.x.getID():
  595.             raise AssertionError
  596.         if self.everything[0].getID() == self.y.getID():
  597.             self.assertEqual(self.everything[1].getID(), self.x.getID())
  598.         
  599.         if self.everything[0].getID() == self.x.getID():
  600.             self.assertEqual(self.everything[1].getID(), self.y.getID())
  601.         
  602.         self.assertEqual(self.everything[2], None)
  603.         if not database.DDBObject().getID() >= last:
  604.             raise AssertionError
  605.  
  606.     
  607.     def testLastID(self):
  608.         last = self.y.getID()
  609.         self.everything.liveStorage.saveDatabase()
  610.         self.y.remove()
  611.         self.x.remove()
  612.         database.DDBObject.lastID = 0
  613.         self.everything.liveStorage = storedatabase.LiveStorage(self.tempdb)
  614.         if not database.DDBObject().getID() > last:
  615.             raise AssertionError
  616.  
  617.  
  618.  
  619. class MapFilterRemoveViewTestCase(DemocracyTestCase):
  620.     
  621.     def setUp(self):
  622.         DemocracyTestCase.setUp(self)
  623.         self.everything = database.defaultDatabase
  624.         self.objlist = []
  625.         for x in range(0, 10):
  626.             database.DDBObject()
  627.         
  628.         self.add = 0
  629.         self.mapped = self.everything.map(self.mapFunc)
  630.         self.mapped = self.mapped.filter((lambda x: True))
  631.  
  632.     
  633.     def mapFunc(self, obj):
  634.         return obj.getID() % 2
  635.  
  636.     
  637.     def testBasicMap(self):
  638.         self.everything.resetCursor()
  639.         self.mapped.resetCursor()
  640.         for obj in self.everything:
  641.             self.assertEqual(self.mapFunc(obj), self.mapped.getNext())
  642.         
  643.  
  644.     
  645.     def testOneOffBasicMap(self):
  646.         self.everything.resetCursor()
  647.         self.mapped.resetCursor()
  648.         for x in range(1, 6):
  649.             obj = self.everything.getNext()
  650.         
  651.         obj.remove()
  652.         self.everything.addBeforeCursor(database.DDBObject(add = False))
  653.         self.everything.getPrev()
  654.         self.everything.getPrev()
  655.         self.everything.addAfterCursor(database.DDBObject(add = False))
  656.         self.everything.resetCursor()
  657.         for obj in self.everything:
  658.             self.assertEqual(self.mapFunc(obj), self.mapped.getObjectByID(obj.getID()))
  659.         
  660.  
  661.  
  662.  
  663. class FilterSortMapTestCase(DemocracyTestCase):
  664.     
  665.     def setUp(self):
  666.         DemocracyTestCase.setUp(self)
  667.         self.everything = database.defaultDatabase
  668.         self.callbacks = 0
  669.         self.objlist = []
  670.         for x in range(0, 10):
  671.             self.objlist.append(database.DDBObject())
  672.         
  673.         
  674.         self.myfiltFunc = lambda x: x.getID() % 2 == 0
  675.         self.filted = self.everything.filter(self.filterFunc)
  676.         self.sorted = self.filted.sort(self.sortFunc)
  677.         self.mapped = self.sorted.map((lambda x: x))
  678.  
  679.     
  680.     def filterFunc(self, x):
  681.         return self.myfiltFunc(x)
  682.  
  683.     
  684.     def sortFunc(self, x, y):
  685.         x = x[1].getID()
  686.         y = y[1].getID()
  687.         return x < y
  688.  
  689.     
  690.     def call(self, obj, id):
  691.         self.callbacks += 1
  692.  
  693.     
  694.     def test(self):
  695.         self.assertEqual(self.mapped.len(), 5)
  696.         self.mapped.addAddCallback(self.call)
  697.         
  698.         self.myfiltFunc = lambda x: x is self.objlist[1]
  699.         self.everything.recomputeFilters()
  700.         self.assertEqual(self.mapped.len(), 1)
  701.         
  702.         self.myfiltFunc = lambda x: True
  703.         self.everything.recomputeFilters()
  704.         self.assertEqual(self.mapped.len(), 10)
  705.  
  706.     
  707.     def testTwoSets(self):
  708.         self.callbacks2 = 0
  709.         
  710.         def call2(item, id):
  711.             self.callbacks2 += 1
  712.  
  713.         
  714.         filtFunc2 = lambda x: True
  715.         filted2 = self.everything.filter(filtFunc2)
  716.         sorted2 = filted2.sort(self.sortFunc)
  717.         mapped2 = sorted2.map((lambda x: x))
  718.         self.mapped.addChangeCallback(self.call)
  719.         mapped2.addChangeCallback(call2)
  720.         if self.myfiltFunc(self.objlist[0]):
  721.             self.objlist[1].signalChange()
  722.         else:
  723.             self.objlist[0].signalChange()
  724.         self.assertEqual(self.callbacks, 0)
  725.         self.assertEqual(self.callbacks2, 1)
  726.         self.everything.recomputeFilters()
  727.         self.assertEqual(self.callbacks, 0)
  728.         self.assertEqual(self.callbacks2, 1)
  729.         self.everything.recomputeFilters()
  730.         self.assertEqual(self.callbacks, 0)
  731.         self.assertEqual(self.callbacks2, 1)
  732.         if self.myfiltFunc(self.objlist[0]):
  733.             self.objlist[0].signalChange()
  734.         else:
  735.             self.objlist[1].signalChange()
  736.         self.assertEqual(self.callbacks, 1)
  737.         self.assertEqual(self.callbacks2, 2)
  738.         self.everything.recomputeFilters()
  739.         self.assertEqual(self.callbacks, 1)
  740.         self.assertEqual(self.callbacks2, 2)
  741.         self.everything.recomputeFilters()
  742.         self.assertEqual(self.callbacks, 1)
  743.         self.assertEqual(self.callbacks2, 2)
  744.  
  745.     
  746.     def testTwoSets2(self):
  747.         self.callbacks2 = 0
  748.         
  749.         def call2(item, id):
  750.             self.callbacks2 += 1
  751.  
  752.         
  753.         filtFunc2 = lambda x: x.getID() % 2 == 1
  754.         filted2 = self.everything.filter(filtFunc2)
  755.         sorted2 = filted2.sort(self.sortFunc)
  756.         mapped2 = sorted2.map((lambda x: x))
  757.         self.mapped.addChangeCallback(self.call)
  758.         mapped2.addChangeCallback(call2)
  759.         self.mapped.addAddCallback(self.call)
  760.         mapped2.addAddCallback(call2)
  761.         self.mapped.addRemoveCallback(self.call)
  762.         mapped2.addRemoveCallback(call2)
  763.         self.mapped.next()
  764.         self.mapped.next()
  765.         self.mapped.next()
  766.         mapped2.next()
  767.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  768.         self.assertEqual(mapped2.cur(), mapped2[0])
  769.         if self.myfiltFunc(self.objlist[0]):
  770.             self.objlist[1].signalChange()
  771.         else:
  772.             self.objlist[0].signalChange()
  773.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  774.         self.assertEqual(mapped2.cur(), mapped2[0])
  775.         self.assertEqual(self.callbacks, 0)
  776.         self.assertEqual(self.callbacks2, 1)
  777.         self.everything.recomputeFilters()
  778.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  779.         self.assertEqual(mapped2.cur(), mapped2[0])
  780.         self.assertEqual(self.callbacks, 0)
  781.         self.assertEqual(self.callbacks2, 1)
  782.         self.everything.recomputeFilters()
  783.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  784.         self.assertEqual(mapped2.cur(), mapped2[0])
  785.         self.assertEqual(self.callbacks, 0)
  786.         self.assertEqual(self.callbacks2, 1)
  787.         if self.myfiltFunc(self.objlist[0]):
  788.             self.objlist[0].signalChange()
  789.         else:
  790.             self.objlist[1].signalChange()
  791.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  792.         self.assertEqual(mapped2.cur(), mapped2[0])
  793.         self.assertEqual(self.callbacks, 1)
  794.         self.assertEqual(self.callbacks2, 1)
  795.         self.everything.recomputeFilters()
  796.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  797.         self.assertEqual(mapped2.cur(), mapped2[0])
  798.         self.assertEqual(self.callbacks, 1)
  799.         self.assertEqual(self.callbacks2, 1)
  800.         self.everything.recomputeFilters()
  801.         self.assertEqual(self.mapped.cur(), self.mapped[2])
  802.         self.assertEqual(mapped2.cur(), mapped2[0])
  803.         self.assertEqual(self.callbacks, 1)
  804.         self.assertEqual(self.callbacks2, 1)
  805.         if self.myfiltFunc(self.objlist[0]):
  806.             self.objlist[0].remove()
  807.         else:
  808.             self.objlist[1].remove()
  809.         self.assertEqual(self.mapped.cur(), self.mapped[1])
  810.         self.assertEqual(mapped2.cur(), mapped2[0])
  811.         self.assertEqual(self.callbacks, 2)
  812.         self.assertEqual(self.callbacks2, 1)
  813.         self.everything.recomputeFilters()
  814.         self.assertEqual(self.mapped.cur(), self.mapped[1])
  815.         self.assertEqual(mapped2.cur(), mapped2[0])
  816.         self.assertEqual(self.callbacks, 2)
  817.         self.assertEqual(self.callbacks2, 1)
  818.         self.everything.recomputeFilters()
  819.         self.assertEqual(self.mapped.cur(), self.mapped[1])
  820.         self.assertEqual(mapped2.cur(), mapped2[0])
  821.         self.assertEqual(self.callbacks, 2)
  822.         self.assertEqual(self.callbacks2, 1)
  823.         self.objlist.append(database.DDBObject(add = False))
  824.         self.objlist.append(database.DDBObject(add = False))
  825.         self.everything.resetCursor()
  826.         self.everything.addAfterCursor(self.objlist[10])
  827.         self.assertEqual(self.everything[0], self.objlist[10])
  828.         self.assertEqual(self.everything.cur(), None)
  829.         self.everything.addAfterCursor(self.objlist[11])
  830.         self.assertEqual(self.everything[0], self.objlist[11])
  831.         self.assertEqual(self.mapped.cur(), self.mapped[1])
  832.         self.assertEqual(mapped2.cur(), mapped2[0])
  833.         self.assertEqual(self.callbacks, 3)
  834.         self.assertEqual(self.callbacks2, 2)
  835.         self.objlist[10].signalChange()
  836.         self.objlist[11].signalChange()
  837.         self.assertEqual(self.mapped.cur(), self.mapped[1])
  838.         self.assertEqual(mapped2.cur(), mapped2[0])
  839.         self.assertEqual(self.callbacks, 4)
  840.         self.assertEqual(self.callbacks2, 3)
  841.         self.everything.recomputeFilters()
  842.         self.assertEqual(self.callbacks, 4)
  843.         self.assertEqual(self.callbacks2, 3)
  844.         
  845.         self.myfiltFunc = lambda x: x is self.objlist[2]
  846.         self.everything.recomputeFilters()
  847.         self.assertEqual(self.callbacks2, 3)
  848.         self.objlist[2].signalChange()
  849.         self.objlist[3].signalChange()
  850.         self.assertEqual(self.callbacks2, 4)
  851.  
  852.  
  853.  
  854. class CursorTestCase(DemocracyTestCase):
  855.     
  856.     def setUp(self):
  857.         DemocracyTestCase.setUp(self)
  858.         self.everything = database.defaultDatabase
  859.         self.origObjs = [
  860.             database.DDBObject(),
  861.             database.DDBObject(),
  862.             database.DDBObject()]
  863.         self.objs = self.everything.filter((lambda x: True)).map(self.mapToObject).sort(self.sortOldID)
  864.  
  865.     
  866.     def sortOldID(self, x, y):
  867.         return x[1].oldID < y[1].oldID
  868.  
  869.     
  870.     def mapToObject(self, obj):
  871.         temp = database.DDBObject(add = False)
  872.         temp.oldID = obj.getID()
  873.         return temp
  874.  
  875.     
  876.     def test(self):
  877.         self.assertEqual(self.objs.len(), 3)
  878.         self.assertEqual(self.objs.cur(), None)
  879.         self.objs.getNext()
  880.         self.objs.getNext()
  881.         self.objs.getNext()
  882.         self.assertEqual(self.objs.cur(), self.objs[2])
  883.         self.origObjs[2].remove()
  884.         self.assertEqual(self.objs.cur(), self.objs[1])
  885.         self.objs.getPrev()
  886.         self.assertEqual(self.objs.cur(), self.objs[0])
  887.  
  888.     
  889.     def testStack(self):
  890.         obj = self.everything.getNext()
  891.         self.assertEqual(self.everything.cur(), obj)
  892.         self.everything.saveCursor()
  893.         while self.everything.getNext() is not None:
  894.             pass
  895.         self.everything.restoreCursor()
  896.         self.assertEqual(self.everything.cur(), obj)
  897.  
  898.  
  899.  
  900. class RecomputeMapTestCase(DemocracyTestCase):
  901.     
  902.     def setUp(self):
  903.         DemocracyTestCase.setUp(self)
  904.         self.everything = database.defaultDatabase
  905.         self.origObjs = [
  906.             database.DDBObject(),
  907.             database.DDBObject(),
  908.             database.DDBObject()]
  909.         self.objs = self.everything.filter((lambda x: True)).map(self.mapToObject).sort(self.sortOldID).map(self.mapToObject)
  910.         self.changeCalls = 0
  911.  
  912.     
  913.     def sortOldID(self, x, y):
  914.         return x[1].oldID < y[1].oldID
  915.  
  916.     
  917.     def mapToObject(self, obj):
  918.         temp = database.DDBObject(add = False)
  919.         temp.oldID = obj.getID()
  920.         return temp
  921.  
  922.     
  923.     def changeCall(self, item, id):
  924.         self.changeCalls += 1
  925.  
  926.     
  927.     def test(self):
  928.         self.objs.addChangeCallback(self.changeCall)
  929.         self.everything.recomputeFilters()
  930.         self.everything.recomputeFilters()
  931.         temp = self.everything.getNext()
  932.         temp.signalChange()
  933.         self.assertEqual(self.changeCalls, 1)
  934.  
  935.  
  936.  
  937. class FilterUpdateOnChange(DemocracyTestCase):
  938.     
  939.     def setUp(self):
  940.         DemocracyTestCase.setUp(self)
  941.         self.everything = database.defaultDatabase
  942.         self.origObjs = [
  943.             database.DDBObject(),
  944.             database.DDBObject(),
  945.             database.DDBObject()]
  946.         self.origObjs[0].good = True
  947.         self.origObjs[1].good = False
  948.         self.origObjs[2].good = False
  949.         self.objs = self.everything.filter((lambda x: x.good))
  950.         self.changeCalls = 0
  951.  
  952.     
  953.     def testLoss(self):
  954.         self.assertEqual(self.objs.len(), 1)
  955.         self.origObjs[0].good = False
  956.         self.origObjs[0].signalChange()
  957.         self.assertEqual(self.objs.len(), 0)
  958.  
  959.     
  960.     def testAdd(self):
  961.         self.assertEqual(self.objs.len(), 1)
  962.         self.origObjs[1].good = True
  963.         self.origObjs[1].signalChange()
  964.         self.assertEqual(self.objs.len(), 2)
  965.  
  966.  
  967.  
  968. class MapUpdateOnChange(DemocracyTestCase):
  969.     
  970.     def setUp(self):
  971.         DemocracyTestCase.setUp(self)
  972.         self.everything = database.defaultDatabase
  973.         self.origObjs = [
  974.             database.DDBObject(),
  975.             database.DDBObject(),
  976.             database.DDBObject()]
  977.         self.origObjs[0].good = True
  978.         self.origObjs[1].good = False
  979.         self.origObjs[2].good = False
  980.         self.objs = self.everything.map(self.mapToObject).filter((lambda x: x.good))
  981.         self.changeCalls = 0
  982.  
  983.     
  984.     def mapToObject(self, obj):
  985.         temp = database.DDBObject(add = False)
  986.         temp.good = obj.good
  987.         return temp
  988.  
  989.     
  990.     def testLoss(self):
  991.         self.assertEqual(self.objs.len(), 1)
  992.         self.origObjs[0].good = False
  993.         self.origObjs[0].signalChange()
  994.         self.assertEqual(self.objs.len(), 1)
  995.  
  996.     
  997.     def testAdd(self):
  998.         self.assertEqual(self.objs.len(), 1)
  999.         self.origObjs[1].good = True
  1000.         self.origObjs[1].signalChange()
  1001.         self.assertEqual(self.objs.len(), 1)
  1002.  
  1003.  
  1004.  
  1005. class SortUpdateOnChange(DemocracyTestCase):
  1006.     
  1007.     def setUp(self):
  1008.         DemocracyTestCase.setUp(self)
  1009.         self.everything = database.defaultDatabase
  1010.         self.origObjs = [
  1011.             database.DDBObject(),
  1012.             database.DDBObject(),
  1013.             database.DDBObject()]
  1014.         self.origObjs[0].good = True
  1015.         self.origObjs[1].good = False
  1016.         self.origObjs[2].good = False
  1017.         self.objs = self.everything.sort((lambda x, y: 0)).sort((lambda x, y: 0)).filter((lambda x: x.good))
  1018.         self.changeCalls = 0
  1019.  
  1020.     
  1021.     def testLoss(self):
  1022.         self.assertEqual(self.objs.len(), 1)
  1023.         self.origObjs[0].good = False
  1024.         self.origObjs[0].signalChange()
  1025.         self.assertEqual(self.objs.len(), 0)
  1026.  
  1027.     
  1028.     def testAdd(self):
  1029.         self.assertEqual(self.objs.len(), 1)
  1030.         self.origObjs[1].good = True
  1031.         self.origObjs[1].signalChange()
  1032.         self.assertEqual(self.objs.len(), 2)
  1033.  
  1034.  
  1035.  
  1036. class IDBaseTraversal(DemocracyTestCase):
  1037.     
  1038.     def setUp(self):
  1039.         DemocracyTestCase.setUp(self)
  1040.         self.everything = database.defaultDatabase
  1041.         self.origObjs = [
  1042.             database.DDBObject(),
  1043.             database.DDBObject(),
  1044.             database.DDBObject()]
  1045.         self.sorted = self.everything.sort(self.sortID)
  1046.  
  1047.     
  1048.     def sortID(self, x, y):
  1049.         return x[1].getID() < y[1].getID()
  1050.  
  1051.     
  1052.     def test(self):
  1053.         self.assertEqual(self.origObjs[0], self.sorted.getObjectByID(self.origObjs[0].getID()))
  1054.         self.assertEqual(self.origObjs[1], self.sorted.getObjectByID(self.origObjs[1].getID()))
  1055.         self.assertEqual(self.origObjs[2], self.sorted.getObjectByID(self.origObjs[2].getID()))
  1056.         self.assertEqual(self.origObjs[1].getID(), self.sorted.getNextID(self.origObjs[0].getID()))
  1057.         self.assertEqual(self.origObjs[2].getID(), self.sorted.getNextID(self.origObjs[1].getID()))
  1058.         self.assertEqual(None, self.sorted.getNextID(self.origObjs[2].getID()))
  1059.         self.assertEqual(None, self.sorted.getPrevID(self.origObjs[0].getID()))
  1060.         self.assertEqual(self.origObjs[0].getID(), self.sorted.getPrevID(self.origObjs[1].getID()))
  1061.         self.assertEqual(self.origObjs[1].getID(), self.sorted.getPrevID(self.origObjs[2].getID()))
  1062.         self.sorted.resetCursor()
  1063.         self.sorted.getNext()
  1064.         self.assertEqual(self.origObjs[0].getID(), self.sorted.getCurrentID())
  1065.         self.sorted.getNext()
  1066.         self.assertEqual(self.origObjs[1].getID(), self.sorted.getCurrentID())
  1067.         self.sorted.getNext()
  1068.         self.assertEqual(self.origObjs[2].getID(), self.sorted.getCurrentID())
  1069.  
  1070.  
  1071.  
  1072. class IndexFilterTestBase(DemocracyTestCase):
  1073.     
  1074.     def setUp(self):
  1075.         DemocracyTestCase.setUp(self)
  1076.         self.everything = database.defaultDatabase
  1077.         self.addCallbacks = 0
  1078.         self.removeCallbacks = 0
  1079.         self.changeCallbacks = 0
  1080.  
  1081.     
  1082.     def addCallback(self, value, id):
  1083.         self.addCallbacks += 1
  1084.  
  1085.     
  1086.     def removeCallback(self, value, id):
  1087.         self.removeCallbacks += 1
  1088.  
  1089.     
  1090.     def changeCallback(self, value, id):
  1091.         self.changeCallbacks += 1
  1092.  
  1093.  
  1094.  
  1095. class IndexFilterTest(IndexFilterTestBase):
  1096.     
  1097.     def setUp(self):
  1098.         IndexFilterTestBase.setUp(self)
  1099.         self.shift = 0
  1100.  
  1101.     
  1102.     def mod10(self, x):
  1103.         return (x.getID() + self.shift) % 10
  1104.  
  1105.     
  1106.     def mod100(self, x):
  1107.         return (x.getID() + self.shift) % 100
  1108.  
  1109.     
  1110.     def sortIndexFunc(self, x, y):
  1111.         return x[1].myValue < y[1].myValue
  1112.  
  1113.     
  1114.     def sortFunc(self, x, y):
  1115.         x = x[1].getID()
  1116.         y = y[1].getID()
  1117.         return x < y
  1118.  
  1119.     
  1120.     def testBasicIndexFilter(self):
  1121.         for x in range(0, 100):
  1122.             database.DDBObject()
  1123.         
  1124.         self.everything.createIndex(self.mod10)
  1125.         filtered = self.everything.filterWithIndex(self.mod10, 0)
  1126.         self.assertEqual(filtered.len(), 10)
  1127.         for x in range(0, 50):
  1128.             database.DDBObject()
  1129.         
  1130.         self.assertEqual(filtered.len(), 15)
  1131.         for i in range(10):
  1132.             obj = self.everything.getItemWithIndex(self.mod10, i)
  1133.             self.assertEqual(self.mod10(obj), i)
  1134.         
  1135.         obj = self.everything.getItemWithIndex(self.mod10, 10)
  1136.         self.assertEqual(obj, None)
  1137.         obj = self.everything.getItemWithIndex(self.mod10, -1, default = 123123)
  1138.         self.assertEqual(obj, 123123)
  1139.         filtered.addAddCallback(self.addCallback)
  1140.         filtered.addRemoveCallback(self.removeCallback)
  1141.         filtered.addChangeCallback(self.changeCallback)
  1142.         for x in range(0, 50):
  1143.             database.DDBObject()
  1144.         
  1145.         self.assertEqual(self.addCallbacks, 5)
  1146.         for obj in filtered:
  1147.             self.assertEqual(self.mod10(obj), 0)
  1148.         
  1149.         filtered[0].remove()
  1150.         self.assertEqual(filtered.len(), 19)
  1151.         self.assertEqual(self.removeCallbacks, 1)
  1152.         filtered[0].signalChange()
  1153.         self.assertEqual(self.changeCallbacks, 1)
  1154.         obj = filtered[0]
  1155.         self.everything.removeView(filtered)
  1156.         for x in range(0, 50):
  1157.             database.DDBObject()
  1158.         
  1159.         self.assertEqual(self.addCallbacks, 5)
  1160.         obj.signalChange()
  1161.         self.assertEqual(self.changeCallbacks, 1)
  1162.         obj.remove()
  1163.         self.assertEqual(self.removeCallbacks, 1)
  1164.  
  1165.     
  1166.     def testIndexChanges(self):
  1167.         
  1168.         class IndexedObject(database.DDBObject):
  1169.             
  1170.             def __init__(self, myValue):
  1171.                 database.DDBObject.__init__(self)
  1172.                 self.myValue = myValue
  1173.  
  1174.  
  1175.         
  1176.         def indexFunc(obj):
  1177.             return obj.myValue
  1178.  
  1179.         foo = IndexedObject('blue')
  1180.         bar = IndexedObject('red')
  1181.         baz = IndexedObject('red')
  1182.         self.everything.createIndex(indexFunc)
  1183.         blueView = self.everything.filterWithIndex(indexFunc, 'blue')
  1184.         redView = self.everything.filterWithIndex(indexFunc, 'red')
  1185.         self.assertEquals(blueView.len(), 1)
  1186.         self.assertEquals(redView.len(), 2)
  1187.         baz.myValue = 'blue'
  1188.         baz.signalChange()
  1189.         self.assertEquals(blueView.len(), 2)
  1190.         self.assertEquals(redView.len(), 1)
  1191.         foo.myValue = 'green'
  1192.         foo.signalChange()
  1193.         greenView = self.everything.filterWithIndex(indexFunc, 'green')
  1194.         self.assertEquals(blueView.len(), 1)
  1195.         self.assertEquals(redView.len(), 1)
  1196.         self.assertEquals(greenView.len(), 1)
  1197.  
  1198.     
  1199.     def testRemoveIndexedView(self):
  1200.         for x in range(0, 100):
  1201.             database.DDBObject()
  1202.         
  1203.         self.everything.createIndex(self.mod10)
  1204.         views = [ self.everything.filterWithIndex(self.mod10, i) for i in range(10) ]
  1205.         for view in views[:5]:
  1206.             self.everything.removeView(view)
  1207.         
  1208.         for view in views[5:]:
  1209.             view.unlink()
  1210.         
  1211.  
  1212.     
  1213.     def testRecomputeIndex(self):
  1214.         for x in range(0, 100):
  1215.             database.DDBObject()
  1216.         
  1217.         self.everything.createIndex(self.mod10)
  1218.         for x in range(0, 50):
  1219.             database.DDBObject()
  1220.         
  1221.         filtered = self.everything.filterWithIndex(self.mod10, 0)
  1222.         for x in range(0, 50):
  1223.             database.DDBObject()
  1224.         
  1225.         self.assertEqual(filtered.len(), 20)
  1226.         filtered[0].remove()
  1227.         self.assertEqual(filtered.len(), 19)
  1228.         self.shift = 1
  1229.         self.everything.recomputeFilters()
  1230.         self.assertEqual(filtered.len(), 20)
  1231.  
  1232.     
  1233.     def testLargeSet(self):
  1234.         self.everything.createIndex(self.mod100)
  1235.         start = time.clock()
  1236.         for x in range(0, 500):
  1237.             database.DDBObject()
  1238.             database.DDBObject()
  1239.             database.DDBObject()
  1240.             database.DDBObject()
  1241.             database.DDBObject()
  1242.             database.DDBObject()
  1243.             database.DDBObject()
  1244.             database.DDBObject()
  1245.             database.DDBObject()
  1246.             database.DDBObject()
  1247.         
  1248.         mid = time.clock()
  1249.         for x in range(0, 500):
  1250.             database.DDBObject()
  1251.             database.DDBObject()
  1252.             database.DDBObject()
  1253.             database.DDBObject()
  1254.             database.DDBObject()
  1255.             database.DDBObject()
  1256.             database.DDBObject()
  1257.             database.DDBObject()
  1258.             database.DDBObject()
  1259.             database.DDBObject()
  1260.         
  1261.         end = time.clock()
  1262.         if not end - mid - mid - start < (mid - start) / 2:
  1263.             raise AssertionError
  1264.         filtered = self.everything.filterWithIndex(self.mod100, 0).sort(self.sortFunc)
  1265.         self.assertEqual(filtered.len(), 100)
  1266.  
  1267.     
  1268.     def testSortedIndex(self):
  1269.         
  1270.         class IndexedObject(database.DDBObject):
  1271.             
  1272.             def __init__(self, myValue):
  1273.                 self.myValue = myValue
  1274.                 database.DDBObject.__init__(self)
  1275.  
  1276.  
  1277.         self.everything.createIndex(self.mod10, self.sortIndexFunc, resort = True)
  1278.         self.objects = []
  1279.         for x in range(100):
  1280.             self.objects.append(IndexedObject(x))
  1281.         
  1282.         filtered = self.everything.filterWithIndex(self.mod10, 0)
  1283.         self.assertEqual(filtered.len(), 10)
  1284.         last = None
  1285.         for obj in filtered:
  1286.             if last is not None:
  1287.                 self.assert_(last.myValue < obj.myValue)
  1288.             
  1289.             last = obj
  1290.         
  1291.         filtered[0].myValue = 1000
  1292.         filtered[1].myValue = -1000
  1293.         unordered = False
  1294.         last = None
  1295.         filtered.resetCursor()
  1296.         for obj in filtered:
  1297.             if last is not None:
  1298.                 if not last.myValue < obj.myValue:
  1299.                     unordered = True
  1300.                 
  1301.             
  1302.             last = obj
  1303.         
  1304.         self.assert_(unordered)
  1305.         filtered[0].signalChange()
  1306.         filtered[1].signalChange()
  1307.         last = None
  1308.         filtered.resetCursor()
  1309.         for obj in filtered:
  1310.             if last is not None:
  1311.                 self.assert_(last.myValue < obj.myValue)
  1312.             
  1313.             last = obj
  1314.         
  1315.         filtered2 = self.everything.filterWithIndex(self.mod10, 0)
  1316.         self.assertEqual(filtered2.len(), 10)
  1317.         last = None
  1318.         for obj in filtered2:
  1319.             if last is not None:
  1320.                 self.assert_(last.myValue < obj.myValue)
  1321.             
  1322.             last = obj
  1323.         
  1324.  
  1325.     
  1326.     def testChangeIndexValue(self):
  1327.         for x in range(0, 100):
  1328.             database.DDBObject()
  1329.         
  1330.         self.everything.createIndex(self.mod10, sortFunc = self.sortFunc, resort = True)
  1331.         filtered = self.everything.filterWithIndex(self.mod10, 0)
  1332.         filtered.addAddCallback(self.addCallback)
  1333.         filtered.addRemoveCallback(self.removeCallback)
  1334.         filtered.addChangeCallback(self.changeCallback)
  1335.         filtered.changeIndexValue(self.mod10, 1)
  1336.         self.assertEqual(filtered.len(), 10)
  1337.         self.assertEqual(self.addCallbacks, 10)
  1338.         self.assertEqual(self.removeCallbacks, 10)
  1339.         self.assertEqual(self.changeCallbacks, 0)
  1340.         filtered.resetCursor()
  1341.         filtered3 = self.everything.filterWithIndex(self.mod10, 0)
  1342.         filtered2 = self.everything.filterWithIndex(self.mod10, 1)
  1343.         for obj in filtered2:
  1344.             self.assertEqual(filtered.getNext().id, obj.id)
  1345.             self.assertNotEqual(filtered3.getNext().id, obj.id)
  1346.         
  1347.         for x in range(0, 100):
  1348.             database.DDBObject()
  1349.         
  1350.         self.assertEqual(filtered.len(), 20)
  1351.         self.assertEqual(self.addCallbacks, 20)
  1352.         filtered.changeIndexValue(self.mod10, 0)
  1353.         filtered.resetCursor()
  1354.         filtered2.resetCursor()
  1355.         filtered3.resetCursor()
  1356.         for obj in filtered3:
  1357.             self.assertEqual(filtered.getNext().id, obj.id)
  1358.             self.assertNotEqual(filtered2.getNext().id, obj.id)
  1359.         
  1360.         self.assertEqual(filtered.len(), 20)
  1361.         self.assertEqual(self.addCallbacks, 40)
  1362.         self.assertEqual(self.removeCallbacks, 30)
  1363.         self.assertEqual(self.changeCallbacks, 0)
  1364.         self.everything.removeView(filtered)
  1365.         for x in range(0, 100):
  1366.             database.DDBObject()
  1367.         
  1368.         self.assertEqual(self.addCallbacks, 40)
  1369.         self.assertEqual(self.removeCallbacks, 30)
  1370.         self.assertEqual(self.changeCallbacks, 0)
  1371.  
  1372.  
  1373.  
  1374. class MultiIndexed(database.DDBObject):
  1375.     
  1376.     def __init__(self, indexValues):
  1377.         self.indexValues = indexValues
  1378.         database.DDBObject.__init__(self)
  1379.  
  1380.  
  1381.  
  1382. def testMultiIndex(obj):
  1383.     return obj.indexValues
  1384.  
  1385.  
  1386. class MultiIndexTestCase(IndexFilterTestBase):
  1387.     
  1388.     def setUp(self):
  1389.         IndexFilterTestBase.setUp(self)
  1390.         random.seed(12341234)
  1391.         self.allObjects = []
  1392.         self.objectsByValueCount = { }
  1393.         for i in range(20):
  1394.             self.newObject()
  1395.         
  1396.         self.everything.createIndex(testMultiIndex, multiValued = True)
  1397.  
  1398.     
  1399.     def genRandomValues(self):
  1400.         values = set()
  1401.         for i in xrange(random.randint(0, 4)):
  1402.             values.add(random.randint(0, 10))
  1403.         
  1404.         return list(values)
  1405.  
  1406.     
  1407.     def newObject(self):
  1408.         indexValues = self.genRandomValues()
  1409.         obj = MultiIndexed(indexValues)
  1410.         self.allObjects.append(obj)
  1411.         
  1412.         try:
  1413.             self.objectsByValueCount[len(indexValues)].append(obj)
  1414.         except KeyError:
  1415.             self.objectsByValueCount[len(indexValues)] = [
  1416.                 obj]
  1417.  
  1418.  
  1419.     
  1420.     def checkViews(self):
  1421.         viewsShouldHave = { }
  1422.         for obj in self.allObjects:
  1423.             for value in obj.indexValues:
  1424.                 
  1425.                 try:
  1426.                     viewsShouldHave[value].add(obj)
  1427.                 continue
  1428.                 except KeyError:
  1429.                     viewsShouldHave[value] = set([
  1430.                         obj])
  1431.                     continue
  1432.                 
  1433.  
  1434.             
  1435.         
  1436.         for value, goal in viewsShouldHave.items():
  1437.             filtered = self.everything.filterWithIndex(testMultiIndex, value)
  1438.             reality = []([ obj for obj in filtered ])
  1439.             self.assertEqual(goal, reality)
  1440.         
  1441.  
  1442.     
  1443.     def testInitalViews(self):
  1444.         self.checkViews()
  1445.  
  1446.     
  1447.     def testRemove(self):
  1448.         while self.allObjects:
  1449.             obj = self.allObjects.pop()
  1450.             obj.remove()
  1451.             self.checkViews()
  1452.  
  1453.     
  1454.     def testChange(self):
  1455.         for obj in self.allObjects:
  1456.             obj.indexValues = self.genRandomValues()
  1457.             obj.signalChange(needsSave = False)
  1458.             self.checkViews()
  1459.         
  1460.  
  1461.     
  1462.     def testCallbacks(self):
  1463.         filtered = self.everything.filterWithIndex(testMultiIndex, 0)
  1464.         filtered.addAddCallback(self.addCallback)
  1465.         filtered.addRemoveCallback(self.removeCallback)
  1466.         filtered.addChangeCallback(self.changeCallback)
  1467.         addCallbackGoal = removeCallbackGoal = changeCallbackGoal = 0
  1468.         for obj in self.allObjects:
  1469.             newValues = self.genRandomValues()
  1470.             if 0 in newValues:
  1471.                 if 0 not in obj.indexValues:
  1472.                     addCallbackGoal += 1
  1473.                 else:
  1474.                     changeCallbackGoal += 1
  1475.             elif 0 in obj.indexValues:
  1476.                 removeCallbackGoal += 1
  1477.             
  1478.             obj.indexValues = newValues
  1479.             obj.signalChange(needsSave = False)
  1480.             self.assertEquals(self.changeCallbacks, changeCallbackGoal)
  1481.             self.assertEquals(self.addCallbacks, addCallbackGoal)
  1482.             self.assertEquals(self.removeCallbacks, removeCallbackGoal)
  1483.         
  1484.  
  1485.  
  1486.  
  1487. class ReSortTestCase(DemocracyTestCase):
  1488.     
  1489.     def setUp(self):
  1490.         DemocracyTestCase.setUp(self)
  1491.         self.everything = database.defaultDatabase
  1492.         self.addCallbacks = 0
  1493.         self.removeCallbacks = 0
  1494.         self.changeCallbacks = 0
  1495.         self.objlist = []
  1496.         for x in range(0, 10):
  1497.             self.objlist.append(SortableObject(x))
  1498.         
  1499.         self.sorted = self.everything.sort(self.sortFunc, resort = True)
  1500.         self.sorted.addAddCallback(self.addCall)
  1501.         self.sorted.addRemoveCallback(self.removeCall)
  1502.         self.sorted.addChangeCallback(self.changeCall)
  1503.  
  1504.     
  1505.     def sortFunc(self, x, y):
  1506.         return x[1].value < y[1].value
  1507.  
  1508.     
  1509.     def addCall(self, obj, id):
  1510.         self.assertEqual(self.sorted.getPrev().getID(), id)
  1511.         self.addCallbacks += 1
  1512.  
  1513.     
  1514.     def removeCall(self, obj, id):
  1515.         self.removeCallbacks += 1
  1516.  
  1517.     
  1518.     def changeCall(self, obj, id):
  1519.         self.changeCallbacks += 1
  1520.  
  1521.     
  1522.     def testResort(self):
  1523.         self.sorted.resetCursor()
  1524.         last = None
  1525.         for obj in self.sorted:
  1526.             if last is not None:
  1527.                 self.assert_(last.value < obj.value)
  1528.             
  1529.             last = obj
  1530.         
  1531.         self.objlist[0].value = 100
  1532.         self.objlist[0].signalChange()
  1533.         self.sorted.resetCursor()
  1534.         last = None
  1535.         for obj in self.sorted:
  1536.             if last is not None:
  1537.                 self.assert_(last.value < obj.value)
  1538.             
  1539.             last = obj
  1540.         
  1541.         self.assertEqual(self.addCallbacks, 1)
  1542.         self.assertEqual(self.removeCallbacks, 1)
  1543.         self.assertEqual(self.changeCallbacks, 0)
  1544.  
  1545.  
  1546.  
  1547. class SortingFilterTestCase(DemocracyTestCase):
  1548.     
  1549.     def setUp(self):
  1550.         DemocracyTestCase.setUp(self)
  1551.         self.everything = database.defaultDatabase
  1552.         self.sortCalls = 0
  1553.         self.objs = []
  1554.         self.reversed = False
  1555.  
  1556.     
  1557.     def sortFunc(self, x, y):
  1558.         self.sortCalls += 1
  1559.         return x[1].value < y[1].value
  1560.  
  1561.     
  1562.     def sortFuncReversable(self, x, y):
  1563.         self.sortCalls += 1
  1564.         retval = x[1].value < y[1].value
  1565.         if self.reversed:
  1566.             retval = not retval
  1567.         
  1568.         return retval
  1569.  
  1570.     
  1571.     def testSort(self):
  1572.         sortView = self.everything.sort(self.sortFunc)
  1573.         for x in range(2000):
  1574.             a = SortableObject(2000)
  1575.             self.objs.append(a)
  1576.         
  1577.         initialSorts = self.sortCalls
  1578.         self.sortCalls = 0
  1579.         filtView = sortView.filter((lambda x: True), sortFunc = self.sortFunc)
  1580.         filterSorts = self.sortCalls
  1581.         self.sortCalls = 0
  1582.         self.assertEqual(sortView.len(), filtView.len())
  1583.         sortView.resetCursor()
  1584.         filtView.resetCursor()
  1585.         for obj in sortView:
  1586.             self.assertEqual(obj, filtView.getNext())
  1587.         
  1588.         self.objs[-1].value = -10
  1589.         self.objs[-1].signalChange()
  1590.         self.objs[-2].value = 0
  1591.         self.objs[-2].signalChange()
  1592.         self.assertEqual(self.sortCalls, 0)
  1593.         sortView.unlink()
  1594.         filtView.unlink()
  1595.  
  1596.     
  1597.     def testResort(self):
  1598.         sortView = self.everything.sort(self.sortFunc, resort = True)
  1599.         for x in range(2000):
  1600.             a = SortableObject(x)
  1601.             self.objs.append(a)
  1602.         
  1603.         initialSorts = self.sortCalls
  1604.         self.sortCalls = 0
  1605.         filtView = sortView.filter((lambda x: True), sortFunc = self.sortFunc, resort = True)
  1606.         filterSorts = self.sortCalls
  1607.         self.sortCalls = 0
  1608.         self.assertEqual(sortView.len(), filtView.len())
  1609.         sortView.resetCursor()
  1610.         filtView.resetCursor()
  1611.         last = None
  1612.         for obj in sortView:
  1613.             self.assertEqual(obj, filtView.getNext())
  1614.             if last != None:
  1615.                 self.assert_(obj.value >= last.value)
  1616.             
  1617.             last = obj
  1618.         
  1619.         self.objs[-1].value = -10
  1620.         self.objs[-1].signalChange()
  1621.         self.objs[-2].value = -1
  1622.         self.objs[-2].signalChange()
  1623.         self.assert_(self.sortCalls > 0)
  1624.         sortView.resetCursor()
  1625.         filtView.resetCursor()
  1626.         last = None
  1627.         for obj in sortView:
  1628.             self.assertEqual(obj, filtView.getNext())
  1629.             if last != None:
  1630.                 self.assert_(obj.value >= last.value)
  1631.             
  1632.             last = obj
  1633.         
  1634.         sortView.unlink()
  1635.         filtView.unlink()
  1636.  
  1637.     
  1638.     def testPerformance(self):
  1639.         sortView = self.everything.sort(self.sortFunc)
  1640.         initialSorts = []
  1641.         filterSorts = []
  1642.         for n in [
  1643.             100,
  1644.             900,
  1645.             9100]:
  1646.             for x in range(n):
  1647.                 a = SortableObject(n)
  1648.                 self.objs.append(a)
  1649.             
  1650.             initialSorts.append(self.sortCalls)
  1651.             self.sortCalls = 0
  1652.             filtView = sortView.filter((lambda x: True), sortFunc = self.sortFunc)
  1653.             filterSorts.append(self.sortCalls)
  1654.             self.sortCalls = 0
  1655.         
  1656.         ratio1 = float(filterSorts[1]) / filterSorts[0]
  1657.         ratio2 = float(filterSorts[2]) / filterSorts[1]
  1658.         self.assert_(abs(ratio1 - ratio2) / ratio1 < 0.01)
  1659.  
  1660.     
  1661.     def testResortFilter(self):
  1662.         filtView = self.everything.filter((lambda : True), resort = True, sortFunc = self.sortFuncReversable)
  1663.         self.reversed = False
  1664.         for i in range(20):
  1665.             a = SortableObject(i)
  1666.             self.objs.append(a)
  1667.         
  1668.         for i in range(20):
  1669.             self.assertEqual(filtView[i].value, i)
  1670.         
  1671.         self.reversed = True
  1672.         for i in range(20):
  1673.             self.assertEqual(filtView[i].value, i)
  1674.         
  1675.         self.everything.recomputeSort(filtView)
  1676.         for i in range(20):
  1677.             self.assertEqual(filtView[i].value, 19 - i)
  1678.         
  1679.  
  1680.     
  1681.     def testExplicitResort(self):
  1682.         
  1683.         def indexFunc(x):
  1684.             return True
  1685.  
  1686.         
  1687.         def indexFunc2(x):
  1688.             return True
  1689.  
  1690.         
  1691.         def multiIndexFunc(x):
  1692.             return [
  1693.                 True]
  1694.  
  1695.         
  1696.         def multiIndexFunc2(x):
  1697.             return [
  1698.                 True]
  1699.  
  1700.         sortView = self.everything.sort(self.sortFunc, resort = True)
  1701.         for x in range(2000):
  1702.             a = SortableObject(x)
  1703.             self.objs.append(a)
  1704.         
  1705.         initialSorts = self.sortCalls
  1706.         self.sortCalls = 0
  1707.         subSort = sortView.sort(self.sortFunc, resort = True)
  1708.         unSubSort = sortView.sort(self.sortFunc, resort = False)
  1709.         sortingFiltView = sortView.filter((lambda x: True), sortFunc = self.sortFunc, resort = True)
  1710.         unsortingFiltView = sortView.filter((lambda x: True), sortFunc = self.sortFunc, resort = False)
  1711.         sortView.createIndex(indexFunc, sortFunc = self.sortFunc, resort = True)
  1712.         sortingIndexView = sortView.filterWithIndex(indexFunc, True)
  1713.         sortView.createIndex(indexFunc2, sortFunc = self.sortFunc, resort = False)
  1714.         unsortingIndexView = sortView.filterWithIndex(indexFunc2, True)
  1715.         sortView.createIndex(multiIndexFunc, sortFunc = self.sortFunc, resort = True, multiValued = True)
  1716.         sortingMultiIndexView = sortView.filterWithIndex(multiIndexFunc, True)
  1717.         sortView.createIndex(multiIndexFunc2, sortFunc = self.sortFunc, resort = False, multiValued = True)
  1718.         unsortingMultiIndexView = sortView.filterWithIndex(multiIndexFunc2, True)
  1719.         allMyViews = [
  1720.             sortingFiltView,
  1721.             unsortingFiltView,
  1722.             sortingIndexView,
  1723.             unsortingIndexView,
  1724.             sortingMultiIndexView,
  1725.             unsortingMultiIndexView,
  1726.             subSort,
  1727.             unSubSort]
  1728.         allSortingViews = [
  1729.             subSort,
  1730.             sortingFiltView,
  1731.             sortingIndexView,
  1732.             sortingMultiIndexView]
  1733.         allUnSortingViews = [
  1734.             unsortingFiltView,
  1735.             unSubSort,
  1736.             unsortingIndexView,
  1737.             unsortingMultiIndexView]
  1738.         for view in allMyViews:
  1739.             self.assertEqual(sortView.len(), view.len())
  1740.             view.resetCursor()
  1741.             last = None
  1742.             sortView.resetCursor()
  1743.             for obj in sortView:
  1744.                 self.assertEqual(obj, view.getNext())
  1745.                 if last != None:
  1746.                     self.assert_(obj.value >= last.value)
  1747.                 
  1748.                 last = obj
  1749.             
  1750.         
  1751.         self.objs[-1].value = -10
  1752.         self.objs[-2].value = -1
  1753.         self.everything.recomputeSort(sortView)
  1754.         self.assert_(self.sortCalls > 0)
  1755.         for view in allUnSortingViews:
  1756.             self.assertEqual(sortView.len(), view.len())
  1757.             view.resetCursor()
  1758.             sortView.resetCursor()
  1759.             for obj in sortView:
  1760.                 self.assertNotEqual(obj, view.getNext())
  1761.             
  1762.         
  1763.         for view in allSortingViews:
  1764.             self.assertEqual(sortView.len(), view.len())
  1765.             view.resetCursor()
  1766.             last = None
  1767.             sortView.resetCursor()
  1768.             for obj in sortView:
  1769.                 self.assertEqual(obj, view.getNext())
  1770.                 if last != None:
  1771.                     self.assert_(obj.value >= last.value)
  1772.                 
  1773.                 last = obj
  1774.             
  1775.         
  1776.         sortView.unlink()
  1777.         for view in allMyViews:
  1778.             view.unlink()
  1779.         
  1780.  
  1781.  
  1782.  
  1783. class UnlinkViewTestCase(DemocracyTestCase):
  1784.     
  1785.     def setUp(self):
  1786.         self.sortCalls = 0
  1787.         DemocracyTestCase.setUp(self)
  1788.         self.everything = database.defaultDatabase
  1789.         self.x = database.DDBObject()
  1790.         self.y = database.DDBObject()
  1791.         self.parent = self.everything.filter((lambda q: True))
  1792.         self.filtered = self.parent.filter((lambda q: True))
  1793.         self.sorted = self.parent.sort(self.sortFunc)
  1794.         self.mapped = self.parent.map((lambda x: x))
  1795.         self.index = self.parent.createIndex(self.indexFunc)
  1796.         self.indexed = self.parent.filterWithIndex(self.indexFunc, True)
  1797.  
  1798.     
  1799.     def indexFunc(self, x):
  1800.         return True
  1801.  
  1802.     
  1803.     def sortFunc(self, x, y):
  1804.         self.sortCalls += 1
  1805.         return str(x[1]) < str(y[1])
  1806.  
  1807.     
  1808.     def testUnlink(self):
  1809.         self.assertEqual(len(self.filtered), len(self.parent))
  1810.         self.assertEqual(len(self.sorted), len(self.parent))
  1811.         self.assertEqual(len(self.mapped), len(self.parent))
  1812.         self.assertEqual(len(self.indexed), len(self.parent))
  1813.         numSort = self.sortCalls
  1814.         self.filtered.unlink()
  1815.         self.sorted.unlink()
  1816.         self.mapped.unlink()
  1817.         self.indexed.unlink()
  1818.         self.x.remove()
  1819.         self.assertNotEqual(len(self.filtered), len(self.parent))
  1820.         self.assertNotEqual(len(self.sorted), len(self.parent))
  1821.         self.assertNotEqual(len(self.mapped), len(self.parent))
  1822.         self.assertNotEqual(len(self.indexed), len(self.parent))
  1823.         self.assertEqual(numSort, self.sortCalls)
  1824.         self.x = database.DDBObject()
  1825.         self.z = database.DDBObject()
  1826.         self.assertNotEqual(len(self.filtered), len(self.parent))
  1827.         self.assertNotEqual(len(self.sorted), len(self.parent))
  1828.         self.assertNotEqual(len(self.mapped), len(self.parent))
  1829.         self.assertNotEqual(len(self.indexed), len(self.parent))
  1830.         self.assertEqual(numSort, self.sortCalls)
  1831.  
  1832.  
  1833. if __name__ == '__main__':
  1834.     unittest.main()
  1835.  
  1836.